# app.py
# from flask import Flask, jsonify
# import psutil
# import socket
# from datetime import datetime
#
# app = Flask(__name__)
#
# @app.route('/')
# def get_system_info():
#     info = {
#         "hostname": socket.gethostname(),
#         "cpu_percent": psutil.cpu_percent(interval=1),
#         "memory": {
#             "total_gb": round(psutil.virtual_memory().total / (1024**3), 2),
#             "used_gb": round(psutil.virtual_memory().used / (1024**3), 2),
#             "percent": psutil.virtual_memory().percent
#         },
#         "disk": {
#             "total_gb": round(psutil.disk_usage('/').total / (1024**3), 2),
#             "used_gb": round(psutil.disk_usage('/').used / (1024**3), 2),
#             "percent": psutil.disk_usage('/').percent
#         },
#         "timestamp": datetime.now().isoformat()
#     }
#     return jsonify(info)
#
# if __name__ == '__main__':
#     app.run(debug=True, host='0.0.0.0', port=5000)



# 最简单的实例启动：返回的Not Found页面 404页面
# from flask import Flask
# from waitress import serve


#实例化一个Flask对象，这个对象就是我们提供的网站内容。网站的所有的东西，都要放在app这个对象里
#通过Flask类实例化得到的app，就是我们的核心对象
# app = Flask(__name__)

#添加路由 url -- 视图函数
# @app.route('/')
# def index():
#     return "this is index"
# app.run()

# if __name__ == '__main__':
#     app.run(debug=True, host='0.0.0.0', port=5000)

            # WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
            #  * Running on http://127.0.0.1:5000
            # Press CTRL+C to quit
            # 127.0.0.1 - - [07/Nov/2025 09:18:05] "GET / HTTP/1.1" 200 -

# 上述输出警告说明：
# 开发阶段 Flask 自带的简易服务器仅用于调试，
# 生产环境应使用专业的 WSGI 服务器（如 Gunicorn、uWSGI）
# 来运行应用，由其处理 HTTP 请求/响应、TCP 连接等底层细节，
# 让 Python 代码专注于业务逻辑和内容生成。

#
# from flask import Flask
#
# app = Flask(__name__)
#
# @app.route('/')
# def index():
#     return "this is index"
#
# # ===== 生产/开发启动逻辑 =====
# if __name__ == '__main__':
#     # 尝试使用 waitress（如果已安装）
#     try:
#         from waitress import serve
#         print("Using Waitress (production-grade server) on http://0.0.0.0:5000")
#         serve(app, host='0.0.0.0', port=5000)
#     except ImportError:
#         # 如果没装 waitress，回退到 Flask 内置服务器
#         print("Waitress not installed. Using Flask development server.")
#         app.run(debug=True, host='0.0.0.0', port=5000)


# ==========请求和响应============
# 响应  --  api响应
# 接口返回的格式一般都是json格式

#标准化返回
# from Lib.resp import  my_response
# from flask import Flask,request
#
# app = Flask(__name__)

# @app.route("/login",endpoint="login",methods = ["GET","POST"])
# def login():
#     request_json = request.get_json()
#     user = request.json.get("user")
#     passwd = request.json.get("passwd")
#     if user == "root" and passwd == "123456":
#         return my_response(data="user:root passwd:123456",message="登陆成功",code=0)
#     else:
#         return my_response(message="登陆失败",code="1")

#     resp.py文件
# def my_response(data, message = "success!",code = 0):
#     if data=="user:root passwd:123456":
#         return {
#                 "code":code,
#                 "message":message,
#                 "data":data
#         }
#     return {
#         "code": 1,
#         "message": "数据格式异常",
#         "data": data
#     }
# 知识点：
# url --- >处理函数
# /student   /teacher
# 在服务端  url和视图函数的映射关系  称为路由
# 也就是说，输入不同的路径，交给不同的函数去处理 ，如下，访问
# /路径，交给index函数去处理
# @app.route('/')
# def index():
#     return "this is index"
    # return my_response()


# @app.route('/hello')
# def hello():
#     return 'hello'

#动态url，通过url传递参数 使用一堆尖括号声明变量
# @app.route("/student/<username>/<userage>")
# def student(username,userage):
#     return f'Hello {username},age is {userage}'


#练习：编写登录路由，通过url传递用户名和密码，支持get和post请求，endpoint指明为loginweb
#  判断用户名和密码是不是root和123456，如果正确返回登录成功，失败返回登陆失败

# @app.route("/loginweb/<root>/<passwd>",methods = ["GET","POST"])
# def loginweb(root,passwd):
#     if root == 'root' and passwd == '123456':
#         return '登陆成功'
#     else:
#         return '登陆失败'

# @app.route("/login", methods = ["GET","POST"])
# def login():
#     # print(dir(request))
#     # print(request.args)
#     # print(request.args.get("username"))
#     # print(request.args.get("passwd"))
#     # return "login html..."
#     # print(request.json.get("username"))
#     # print(request.json.get("passwd"))
#     print(request.form.get("username"),request.form.get("passwd"))
#     print(request.url)
#     print(request.path)
#     print(request.headers)
#     print(request.method)

    # return "login html...."






# app.run()
# if __name__ == '__main__':
# app.run(debug=True)
# debug = True 会在代码修复后自动重启服务器，开发时非常方便


# if __name__ == '__main__':
# 讲一下这个东西的作用，为什么需要它？
# 首先，它的作用是防止程序自动执行
# 当这个文件（app.py）作为一个模块导入到其他文件的时候，
# 如果没有这个东西，就会导致app.py文件自动执行，而加上这个，
# 顾名思义，if 它的 name 是main  ，意思是如果app.py是主程序
# 那么就运行，否则就作为模块乖乖别动

# # ========== 启动逻辑 ==========
# if __name__ == '__main__':
#     # 使用 Waitress 作为 WSGI 服务器（支持 Windows，无开发警告）
#     from waitress import serve
#     print("Starting server with Waitress on http://0.0.0.0:5000")
#     serve(app, host='0.0.0.0', port=5000)



# @app.route("/login",endpoint="login",methods = ["GET","POST"])
# def login():
#     request_json = request.get_json()
#     user = request.json.get("user")
#     passwd = request.json.get("passwd")
#     if user == "root" and passwd == "123456":
#         return my_response(data="user:root passwd:123456",message="登陆成功",code=0)
#     else:
#         return my_response(message="登陆失败",code="1")
# 如果是GET请求（直接访问/login）


# ============非前后端分离===========
# from flask import Flask, render_template, request
#
# app = Flask(__name__)
#
# @app.route("/")
# def index():
#     return render_template("index.html")
#
# @app.route("/login", methods=["GET", "POST"])
# def login():
#     # 如果是POST请求（表单提交）
#     if request.method == "POST":
#         user = request.form.get("user")
#         password = request.form.get("password")
#         print(user, password)
#         return "登录成功（这里可以添加验证逻辑）"
#     else:
#         return render_template("index.html")  # 渲染登录表单页面
#
# if __name__ == "__main__":
#     app.run(debug=True)

# 需要区分GET 请求和POST 请求的逻辑：
# GET 请求：渲染登录页面（展示表单）。
# POST 请求：处理表单提交（获取用户名、密码并验证）。


#在上面的代码中（已经很完善了，只不过缺少了登录成功的验证逻辑），密码正确与否都会登录成功。
# 此登陆成功非彼登陆成功，这里返回的“登录成功”字符串仅仅是告知用户登录时得到后端正确响应了
# 而非真正的输入正确密码登录成功
# 因此执行以下操作（前面已经学过）：
# def my_response(data, message = "success!",code = 0):
#     if data=="user:root passwd:123456":
#         return {
#                 "code":code,
#                 "message":message,
#                 "data":data
#         }
#     return {
#         "code": 1,
#         "message": "数据格式异常",
#         "data": data
#     }

# @app.route("/login",endpoint="login",methods = ["GET","POST"])
# def login():
#     request_json = request.get_json()
#     user = request.json.get("user")
#     passwd = request.json.get("passwd")
#     if user == "root" and passwd == "123456":
#         return my_response(data="user:root passwd:123456",message="登陆成功",code=0)
#     else:
#         return my_response(message="登陆失败",code="1")




# ===========对上述代码进行最后的整理
# 修改主要完成了多场景登录验证的整合与响应格式的统一规范，具体总结如下：
# 一、功能整合
# 将 ** 表单提交（传统前端场景）和JSON 请求（前后端分离场景）** 的登录逻辑整合到同一个 /login 路由中，实现了：
# 当以表单方式提交登录信息时，能正确解析 user 和 passwd 字段并验证；
# 当以JSON 方式（如 Postman 发送 JSON 请求）提交登录信息时，也能解析 user 和 passwd 字段并验证。
# 二、响应格式统一
# 通过 my_response 函数实现了所有登录响应的格式标准化，返回结构固定包含：
# code：状态码（0 表示成功，1 表示失败 / 异常）；
# message：提示信息（如 “登录成功”“登录失败”）；
# data：业务数据（如成功时的用户信息标识）。
# 三、代码结构优化
# 路由逻辑清晰区分了 GET 和 POST 请求：GET 请求渲染登录页面，POST 请求处理登录验证；
# 对 POST 请求进一步区分了表单提交和JSON 请求的解析逻辑，确保不同场景下的兼容性；
# 所有响应最终通过 jsonify 转换为 JSON 格式返回，保证前端（或调用方）能以统一的方式解析结果。

# from flask import Flask, render_template, request, jsonify
# import json
# app = Flask(__name__)
#
# # 配置 JSON 编码器，确保中文正常显示（不转义 Unicode）
# class CustomJSONEncoder(json.JSONEncoder):
#     def default(self, obj):
#         return super().default(obj)
# app.json_encoder = CustomJSONEncoder
# app.config['JSON_AS_ASCII'] = False  # 关键：关闭 ASCII 编码，支持中文
# # 定义响应格式化函数
# def my_response(data=None, message="success!", code=0):
#     if data == "user:root passwd:123456":
#         return {
#             "code": code,
#             "message": message,
#             "data": data
#         }
#     return {
#         "code": 1,
#         "message": "数据格式异常",
#         "data": data
#     }
#
#
# @app.route("/")
# def index():
#     return render_template("index.html")  # 渲染登录页面
#
#
# @app.route("/login", methods=["GET", "POST"])
# def login():
#     # 处理GET请求：渲染登录页面
#     if request.method == "GET":
#         return render_template("index.html")
#
#     # 处理POST请求：区分表单提交和JSON请求
#     elif request.method == "POST":
#         # 尝试解析JSON请求（前后端分离场景）
#         json_data = request.get_json(silent=True)
#         if json_data:
#             user = json_data.get("user")
#             passwd = json_data.get("passwd")
#             if user == "root" and passwd == "123456":
#                 response = my_response(data="user:root passwd:123456", message="登录成功", code=0)
#                 return jsonify(response)
#             else:
#                 response = my_response(message="登录失败（JSON验证）", code=1)
#                 return jsonify(response)
#
#         # 解析表单提交（传统表单场景）
#         else:
#             user = request.form.get("user")
#             passwd = request.form.get("passwd")  # 注意前端name是passwd
#             if user == "root" and passwd == "123456":
#                 response = my_response(data=f"user:{user} passwd:{passwd}", message="登录成功", code=0)
#                 return jsonify(response)
#             else:
#                 response = my_response(message="登录失败（表单验证）", code=1)
#                 return jsonify(response)
#
#
# if __name__ == "__main__":
#     app.run(debug=True)


# from flask import Flask, render_template, request, jsonify
# import json
#
# app = Flask(__name__)
#
# # 配置中文显示
# app.config['JSON_AS_ASCII'] = False
#
#
# # 简化响应函数
# def my_response(data=None, message="success!", code=0):
#     return {
#         "code": code,
#         "message": message,
#         "data": data
#     }
#
#
# @app.route("/")
# def index():
#     return render_template("index.html")
#
#
# @app.route("/login", methods=["GET", "POST"])
# def login():
#     if request.method == "GET":
#         return render_template("index.html")
#
#     if request.is_json:
#         json_data = request.get_json(silent=True) or {}
#         user = json_data.get("user")
#         passwd = json_data.get("passwd")
#     else:
#         user = request.form.get("user")
#         passwd = request.form.get("passwd")
#
#     if user == "root" and passwd == "123456":
#         return jsonify(my_response(
#             data=f"user:{user} passwd:{passwd}",
#             message="登录成功",
#             code=0
#         ))
#     else:
#         return jsonify(my_response(
#             message="登录失败（用户名或密码错误）",
#             code=1
#         ))
#
#
# if __name__ == "__main__":
#     app.run(debug=True)




from flask import Flask, render_template, request, jsonify, redirect, url_for
import json

app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False


# 响应函数（用于API交互）
def my_response(data=None, message="success!", code=0):
    return {
        "code": code,
        "message": message,
        "data": data
    }


# 登录页
@app.route("/")
def login_page():
    return render_template("login.html")


# 登录处理（验证后跳转）
@app.route("/login", methods=["POST"])
def login():
    if request.is_json:
        data = request.get_json(silent=True) or {}
        user = data.get("user")
        passwd = data.get("passwd")
    else:
        user = request.form.get("user")
        passwd = request.form.get("passwd")

    # 验证成功：跳转到成功页
    if user == "root" and passwd == "123456":
        return redirect(url_for("success_page", user=user))  # 携带用户名跳转
    # 验证失败：跳转到失败页
    else:
        return redirect(url_for("fail_page"))


# 登录成功页
@app.route("/success")
def success_page():
    user = request.args.get("user", "用户")  # 获取跳转时携带的用户名
    return render_template("success.html", user=user)


# 登录失败页
@app.route("/fail")
def fail_page():
    return render_template("fail.html")


if __name__ == "__main__":
    app.run(debug=True)












